// 通用网络请求工具
const app = getApp();

/**
 * 封装wx.request请求
 * @param {Object} options 请求配置
 * @param {string} options.url 请求URL
 * @param {string} options.method 请求方法
 * @param {Object} options.data 请求数据
 * @param {boolean} options.loading 是否显示加载中
 * @param {boolean} options.auth 是否需要认证
 */
const request = (options = {}) => {
  return new Promise((resolve, reject) => {
    console.log(`[${options.method || 'GET'}] 请求开始: ${options.url}`);
    console.log('请求参数:', options.data);

    // 是否需要携带token
    const needToken = options.needToken !== false;
    // 是否使用默认错误处理
    const useDefaultErrorHandler = options.useDefaultErrorHandler !== false;
    
    // 默认请求头
    const header = {
      'content-type': 'application/json'
    };
    
    // 如果需要token，从本地存储获取
    if (needToken) {
      // 优先从全局变量获取token，如果没有再从本地存储获取
      let token = app.globalData && app.globalData.token;
      if (!token) {
        token = wx.getStorageSync('token');
        // 如果从存储中获取到了，同时更新全局变量
        if (token && app.globalData) {
          app.globalData.token = token;
        }
      }
      
      if (token) {
        // 确保token是字符串类型
        token = String(token);
        // 检查token是否已经包含Bearer前缀
        if (token.indexOf('Bearer ') === 0) {
          header.Authorization = token;
          console.log('使用已有Bearer前缀的token:', token);
        } else {
          header.Authorization = `Bearer ${token}`;
          console.log('添加Bearer前缀到token:', `Bearer ${token}`);
        }
      } else {
        console.warn('请求需要token但未找到token');
      }
    }
    
    // 合并自定义请求头
    if (options.header) {
      Object.assign(header, options.header);
    }
    
    console.log('最终请求头:', header);
    
    // 拼接完整URL
    const baseUrl = app.globalData.baseUrl || 'http://localhost:8080/api';
    const url = options.url.startsWith('http') ? options.url : baseUrl + options.url;
    
    // 发送请求
    wx.request({
      url,
      data: options.data,
      method: options.method || 'GET',
      header,
      success(res) {
        console.log(`[${options.method || 'GET'}] 请求成功:`, res);
        console.log(`[${options.method || 'GET'}] 响应数据类型:`, typeof res.data, Array.isArray(res.data) ? '是数组' : '不是数组');
        
        if (res.data && res.data.code !== undefined) {
          console.log(`[${options.method || 'GET'}] 响应状态码:`, res.data.code);
        }
        
        // 请求成功且状态码为200
        if (res.statusCode === 200) {
          // 对返回结果进行兼容处理
          // 1. 正常情况：res.data是带有code和data字段的对象
          // 2. 简化情况：res.data直接是返回的业务数据
          // 3. 异常情况：res.data中包含错误信息message
          
          // 情况1：标准结构的API返回
          if (res.data && (res.data.code === 200 || res.data.code === 0)) {
            // 原始行为：只返回data字段
            // 新行为：返回整个响应对象
            // 为了兼容，这里恢复原始行为，返回data字段
            resolve(res.data.data);
          } 
          // 情况2：直接返回数据的API
          else if (res.data && !res.data.code && !res.data.message) {
            resolve(res.data);
          }
          // 情况3：返回错误信息
          else {
            const errorMsg = (res.data && res.data.message) || '请求失败';
            console.error('业务处理失败:', res.data);
            
            if (useDefaultErrorHandler) {
              wx.showToast({
                title: errorMsg,
                icon: 'none'
              });
            }
            
            // 401表示未登录或token过期，需要重新登录
            if (res.data && res.data.code === 401) {
              console.log('收到401状态码，需要重新登录');
              
              // 清除登录信息
              if (app.clearUserInfo) {
                app.clearUserInfo();
                console.log('已清除用户登录信息');
              }
              
              // 跳转到登录页
              wx.showModal({
                title: '提示',
                content: '登录已过期，请重新登录',
                showCancel: false,
                success() {
                  wx.navigateTo({
                    url: '/pages/login/login'
                  });
                }
              });
            }
            
            reject(new Error(errorMsg));
          }
        } else {
          console.error('HTTP状态码错误:', res.statusCode);
          
          // 处理HTTP错误
          let errorMsg = '网络请求失败';
          
          if (res.statusCode === 401) {
            errorMsg = '请先登录';
            console.log('收到401状态码，需要重新登录');
            
            // 清除登录信息
            if (app.clearUserInfo) {
              app.clearUserInfo();
              console.log('已清除用户登录信息');
            }
            
            // 跳转到登录页
            wx.showModal({
              title: '提示',
              content: '登录已过期，请重新登录',
              showCancel: false,
              success() {
                wx.navigateTo({
                  url: '/pages/login/login'
                });
              }
            });
          } else if (res.statusCode === 404) {
            errorMsg = '请求的资源不存在';
          } else if (res.statusCode === 500) {
            errorMsg = '服务器内部错误';
          }
          
          if (useDefaultErrorHandler) {
            wx.showToast({
              title: errorMsg,
              icon: 'none'
            });
          }
          
          reject(new Error(errorMsg));
        }
      },
      fail(err) {
        console.error(`[${options.method || 'GET'}] 请求失败:`, err);
        
        const errorMsg = err.errMsg || '请求失败';
        
        if (useDefaultErrorHandler) {
          wx.showToast({
            title: errorMsg,
            icon: 'none'
          });
        }
        
        reject(new Error(errorMsg));
      },
      complete() {
        console.log(`[${options.method || 'GET'}] 请求完成: ${options.url}`);
      }
    });
  });
};

// 导出请求方法
module.exports = {
  // GET请求
  get: (url, data = {}, needToken = true, useDefaultErrorHandler = true) => {
    return request({
      url,
      data,
      method: 'GET',
      needToken,
      useDefaultErrorHandler
    });
  },
  
  // POST请求
  post: (url, data = {}, needToken = true, useDefaultErrorHandler = true) => {
    return request({
      url,
      data,
      method: 'POST',
      needToken,
      useDefaultErrorHandler
    });
  },
  
  // PUT请求
  put: (url, data = {}, needToken = true, useDefaultErrorHandler = true) => {
    return request({
      url,
      data,
      method: 'PUT',
      needToken,
      useDefaultErrorHandler
    });
  },
  
  // DELETE请求
  delete: (url, data = {}, needToken = true, useDefaultErrorHandler = true) => {
    return request({
      url,
      data,
      method: 'DELETE',
      needToken,
      useDefaultErrorHandler
    });
  }
}; 